home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / js / jsscan.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  16KB  |  364 lines
  1. /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is Mozilla Communicator client code, released
  17.  * March 31, 1998.
  18.  *
  19.  * The Initial Developer of the Original Code is
  20.  * Netscape Communications Corporation.
  21.  * Portions created by the Initial Developer are Copyright (C) 1998
  22.  * the Initial Developer. All Rights Reserved.
  23.  *
  24.  * Contributor(s):
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. #ifndef jsscan_h___
  41. #define jsscan_h___
  42. /*
  43.  * JS lexical scanner interface.
  44.  */
  45. #include <stddef.h>
  46. #include <stdio.h>
  47. #include "jsopcode.h"
  48. #include "jsprvtd.h"
  49. #include "jspubtd.h"
  50.  
  51. JS_BEGIN_EXTERN_C
  52.  
  53. typedef enum JSTokenType {
  54.     TOK_ERROR = -1,                     /* well-known as the only code < EOF */
  55.     TOK_EOF = 0,                        /* end of file */
  56.     TOK_EOL = 1,                        /* end of line */
  57.     TOK_SEMI = 2,                       /* semicolon */
  58.     TOK_COMMA = 3,                      /* comma operator */
  59.     TOK_ASSIGN = 4,                     /* assignment ops (= += -= etc.) */
  60.     TOK_HOOK = 5, TOK_COLON = 6,        /* conditional (?:) */
  61.     TOK_OR = 7,                         /* logical or (||) */
  62.     TOK_AND = 8,                        /* logical and (&&) */
  63.     TOK_BITOR = 9,                      /* bitwise-or (|) */
  64.     TOK_BITXOR = 10,                    /* bitwise-xor (^) */
  65.     TOK_BITAND = 11,                    /* bitwise-and (&) */
  66.     TOK_EQOP = 12,                      /* equality ops (== !=) */
  67.     TOK_RELOP = 13,                     /* relational ops (< <= > >=) */
  68.     TOK_SHOP = 14,                      /* shift ops (<< >> >>>) */
  69.     TOK_PLUS = 15,                      /* plus */
  70.     TOK_MINUS = 16,                     /* minus */
  71.     TOK_STAR = 17, TOK_DIVOP = 18,      /* multiply/divide ops (* / %) */
  72.     TOK_UNARYOP = 19,                   /* unary prefix operator */
  73.     TOK_INC = 20, TOK_DEC = 21,         /* increment/decrement (++ --) */
  74.     TOK_DOT = 22,                       /* member operator (.) */
  75.     TOK_LB = 23, TOK_RB = 24,           /* left and right brackets */
  76.     TOK_LC = 25, TOK_RC = 26,           /* left and right curlies (braces) */
  77.     TOK_LP = 27, TOK_RP = 28,           /* left and right parentheses */
  78.     TOK_NAME = 29,                      /* identifier */
  79.     TOK_NUMBER = 30,                    /* numeric constant */
  80.     TOK_STRING = 31,                    /* string constant */
  81.     TOK_OBJECT = 32,                    /* RegExp or other object constant */
  82.     TOK_PRIMARY = 33,                   /* true, false, null, this, super */
  83.     TOK_FUNCTION = 34,                  /* function keyword */
  84.     TOK_EXPORT = 35,                    /* export keyword */
  85.     TOK_IMPORT = 36,                    /* import keyword */
  86.     TOK_IF = 37,                        /* if keyword */
  87.     TOK_ELSE = 38,                      /* else keyword */
  88.     TOK_SWITCH = 39,                    /* switch keyword */
  89.     TOK_CASE = 40,                      /* case keyword */
  90.     TOK_DEFAULT = 41,                   /* default keyword */
  91.     TOK_WHILE = 42,                     /* while keyword */
  92.     TOK_DO = 43,                        /* do keyword */
  93.     TOK_FOR = 44,                       /* for keyword */
  94.     TOK_BREAK = 45,                     /* break keyword */
  95.     TOK_CONTINUE = 46,                  /* continue keyword */
  96.     TOK_IN = 47,                        /* in keyword */
  97.     TOK_VAR = 48,                       /* var keyword */
  98.     TOK_WITH = 49,                      /* with keyword */
  99.     TOK_RETURN = 50,                    /* return keyword */
  100.     TOK_NEW = 51,                       /* new keyword */
  101.     TOK_DELETE = 52,                    /* delete keyword */
  102.     TOK_DEFSHARP = 53,                  /* #n= for object/array initializers */
  103.     TOK_USESHARP = 54,                  /* #n# for object/array initializers */
  104.     TOK_TRY = 55,                       /* try keyword */
  105.     TOK_CATCH = 56,                     /* catch keyword */
  106.     TOK_FINALLY = 57,                   /* finally keyword */
  107.     TOK_THROW = 58,                     /* throw keyword */
  108.     TOK_INSTANCEOF = 59,                /* instanceof keyword */
  109.     TOK_DEBUGGER = 60,                  /* debugger keyword */
  110.     TOK_XMLSTAGO = 61,                  /* XML start tag open (<) */
  111.     TOK_XMLETAGO = 62,                  /* XML end tag open (</) */
  112.     TOK_XMLPTAGC = 63,                  /* XML point tag close (/>) */
  113.     TOK_XMLTAGC = 64,                   /* XML start or end tag close (>) */
  114.     TOK_XMLNAME = 65,                   /* XML start-tag non-final fragment */
  115.     TOK_XMLATTR = 66,                   /* XML quoted attribute value */
  116.     TOK_XMLSPACE = 67,                  /* XML whitespace */
  117.     TOK_XMLTEXT = 68,                   /* XML text */
  118.     TOK_XMLCOMMENT = 69,                /* XML comment */
  119.     TOK_XMLCDATA = 70,                  /* XML CDATA section */
  120.     TOK_XMLPI = 71,                     /* XML processing instruction */
  121.     TOK_AT = 72,                        /* XML attribute op (@) */
  122.     TOK_DBLCOLON = 73,                  /* namespace qualified name op (::) */
  123.     TOK_ANYNAME = 74,                   /* XML AnyName singleton (*) */
  124.     TOK_DBLDOT = 75,                    /* XML descendant op (..) */
  125.     TOK_FILTER = 76,                    /* XML filtering predicate op (.()) */
  126.     TOK_XMLELEM = 77,                   /* XML element node type (no token) */
  127.     TOK_XMLLIST = 78,                   /* XML list node type (no token) */
  128.     TOK_RESERVED,                       /* reserved keywords */
  129.     TOK_LIMIT                           /* domain size */
  130. } JSTokenType;
  131.  
  132. #define IS_PRIMARY_TOKEN(tt) \
  133.     ((uintN)((tt) - TOK_NAME) <= (uintN)(TOK_PRIMARY - TOK_NAME))
  134.  
  135. #define TOKEN_TYPE_IS_XML(tt) \
  136.     (tt == TOK_AT || tt == TOK_DBLCOLON || tt == TOK_ANYNAME)
  137.  
  138. struct JSStringBuffer {
  139.     jschar      *base;
  140.     jschar      *limit;         /* length limit for quick bounds check */
  141.     jschar      *ptr;           /* slot for next non-NUL char to store */
  142.     void        *data;
  143.     JSBool      (*grow)(JSStringBuffer *sb, size_t newlength);
  144.     void        (*free)(JSStringBuffer *sb);
  145. };
  146.  
  147. #define STRING_BUFFER_ERROR_BASE        ((jschar *) 1)
  148. #define STRING_BUFFER_OK(sb)            ((sb)->base != STRING_BUFFER_ERROR_BASE)
  149. #define STRING_BUFFER_OFFSET(sb)        ((sb)->ptr -(sb)->base)
  150.  
  151. extern void
  152. js_InitStringBuffer(JSStringBuffer *sb);
  153.  
  154. extern void
  155. js_FinishStringBuffer(JSStringBuffer *sb);
  156.  
  157. extern void
  158. js_AppendChar(JSStringBuffer *sb, jschar c);
  159.  
  160. extern void
  161. js_RepeatChar(JSStringBuffer *sb, jschar c, uintN count);
  162.  
  163. extern void
  164. js_AppendCString(JSStringBuffer *sb, const char *asciiz);
  165.  
  166. extern void
  167. js_AppendJSString(JSStringBuffer *sb, JSString *str);
  168.  
  169. struct JSTokenPtr {
  170.     uint16              index;          /* index of char in physical line */
  171.     uint16              lineno;         /* physical line number */
  172. };
  173.  
  174. struct JSTokenPos {
  175.     JSTokenPtr          begin;          /* first character and line of token */
  176.     JSTokenPtr          end;            /* index 1 past last char, last line */
  177. };
  178.  
  179. struct JSToken {
  180.     JSTokenType         type;           /* char value or above enumerator */
  181.     JSTokenPos          pos;            /* token position in file */
  182.     jschar              *ptr;           /* beginning of token in line buffer */
  183.     union {
  184.         struct {                        /* non-numeric literal */
  185.             JSOp        op;             /* operator, for minimal parser */
  186.             JSAtom      *atom;          /* atom table entry */
  187.         } s;
  188.         struct {                        /* atom pair, for XML PIs */
  189.             JSAtom      *atom2;         /* auxiliary atom table entry */
  190.             JSAtom      *atom;          /* main atom table entry */
  191.         } p;
  192.         jsdouble        dval;           /* floating point number */
  193.     } u;
  194. };
  195.  
  196. #define t_op            u.s.op
  197. #define t_atom          u.s.atom
  198. #define t_atom2         u.p.atom2
  199. #define t_dval          u.dval
  200.  
  201. typedef struct JSTokenBuf {
  202.     jschar              *base;          /* base of line or stream buffer */
  203.     jschar              *limit;         /* limit for quick bounds check */
  204.     jschar              *ptr;           /* next char to get, or slot to use */
  205. } JSTokenBuf;
  206.  
  207. #define JS_LINE_LIMIT   256             /* logical line buffer size limit --
  208.                                            physical line length is unlimited */
  209. #define NTOKENS         4               /* 1 current + 2 lookahead, rounded */
  210. #define NTOKENS_MASK    (NTOKENS-1)     /* to power of 2 to avoid divmod by 3 */
  211.  
  212. struct JSTokenStream {
  213.     JSToken             tokens[NTOKENS];/* circular token buffer */
  214.     uintN               cursor;         /* index of last parsed token */
  215.     uintN               lookahead;      /* count of lookahead tokens */
  216.     uintN               lineno;         /* current line number */
  217.     uintN               ungetpos;       /* next free char slot in ungetbuf */
  218.     jschar              ungetbuf[6];    /* at most 6, for \uXXXX lookahead */
  219.     uintN               flags;          /* flags -- see below */
  220.     ptrdiff_t           linelen;        /* physical linebuf segment length */
  221.     ptrdiff_t           linepos;        /* linebuf offset in physical line */
  222.     JSTokenBuf          linebuf;        /* line buffer for diagnostics */
  223.     JSTokenBuf          userbuf;        /* user input buffer if !file */
  224.     JSStringBuffer      tokenbuf;       /* current token string buffer */
  225.     const char          *filename;      /* input filename or null */
  226.     FILE                *file;          /* stdio stream if reading from file */
  227.     JSPrincipals        *principals;    /* principals associated with source */
  228.     JSSourceHandler     listener;       /* callback for source; eg debugger */
  229.     void                *listenerData;  /* listener 'this' data */
  230.     void                *listenerTSData;/* listener data for this TokenStream */
  231.     jschar              *saveEOL;       /* save next end of line in userbuf, to
  232.                                            optimize for very long lines */
  233. };
  234.  
  235. #define CURRENT_TOKEN(ts)       ((ts)->tokens[(ts)->cursor])
  236. #define ON_CURRENT_LINE(ts,pos) ((uint16)(ts)->lineno == (pos).end.lineno)
  237.  
  238. /* JSTokenStream flags */
  239. #define TSF_ERROR       0x01            /* fatal error while compiling */
  240. #define TSF_EOF         0x02            /* hit end of file */
  241. #define TSF_NEWLINES    0x04            /* tokenize newlines */
  242. #define TSF_OPERAND     0x08            /* looking for operand, not operator */
  243. #define TSF_NLFLAG      0x20            /* last linebuf ended with \n */
  244. #define TSF_CRFLAG      0x40            /* linebuf would have ended with \r */
  245. #define TSF_DIRTYLINE   0x80            /* non-whitespace since start of line */
  246. #define TSF_OWNFILENAME 0x100           /* ts->filename is malloc'd */
  247. #define TSF_XMLTAGMODE  0x200           /* scanning within an XML tag in E4X */
  248. #define TSF_XMLTEXTMODE 0x400           /* scanning XMLText terminal from E4X */
  249. #define TSF_XMLONLYMODE 0x800           /* don't scan {expr} within text/tag */
  250.  
  251. /* Flag indicating unexpected end of input, i.e. TOK_EOF not at top-level. */
  252. #define TSF_UNEXPECTED_EOF 0x1000
  253.  
  254. /*
  255.  * To handle the hard case of contiguous HTML comments, we want to clear the
  256.  * TSF_DIRTYINPUT flag at the end of each such comment.  But we'd rather not
  257.  * scan for --> within every //-style comment unless we have to.  So we set
  258.  * TSF_IN_HTML_COMMENT when a <!-- is scanned as an HTML begin-comment, and
  259.  * clear it (and TSF_DIRTYINPUT) when we scan --> either on a clean line, or
  260.  * only if (ts->flags & TSF_IN_HTML_COMMENT), in a //-style comment.
  261.  *
  262.  * This still works as before given a malformed comment hiding hack such as:
  263.  *
  264.  *    <script>
  265.  *      <!-- comment hiding hack #1
  266.  *      code goes here
  267.  *      // --> oops, markup for script-unaware browsers goes here!
  268.  *    </script>
  269.  *
  270.  * It does not cope with malformed comment hiding hacks where --> is hidden
  271.  * by C-style comments, or on a dirty line.  Such cases are already broken.
  272.  */
  273. #define TSF_IN_HTML_COMMENT 0x2000
  274.  
  275. /* Unicode separators that are treated as line terminators, in addition to \n, \r */
  276. #define LINE_SEPARATOR  0x2028
  277. #define PARA_SEPARATOR  0x2029
  278.  
  279. /*
  280.  * Create a new token stream, either from an input buffer or from a file.
  281.  * Return null on file-open or memory-allocation failure.
  282.  *
  283.  * NB: All of js_New{,Buffer,File}TokenStream() return a pointer to transient
  284.  * memory in the current context's temp pool.  This memory is deallocated via
  285.  * JS_ARENA_RELEASE() after parsing is finished.
  286.  */
  287. extern JSTokenStream *
  288. js_NewTokenStream(JSContext *cx, const jschar *base, size_t length,
  289.                   const char *filename, uintN lineno, JSPrincipals *principals);
  290.  
  291. extern JS_FRIEND_API(JSTokenStream *)
  292. js_NewBufferTokenStream(JSContext *cx, const jschar *base, size_t length);
  293.  
  294. extern JS_FRIEND_API(JSTokenStream *)
  295. js_NewFileTokenStream(JSContext *cx, const char *filename, FILE *defaultfp);
  296.  
  297. extern JS_FRIEND_API(JSBool)
  298. js_CloseTokenStream(JSContext *cx, JSTokenStream *ts);
  299.  
  300. extern JS_FRIEND_API(int)
  301. js_fgets(char *buf, int size, FILE *file);
  302.  
  303. /*
  304.  * Initialize the scanner, installing JS keywords into cx's global scope.
  305.  */
  306. extern JSBool
  307. js_InitScanner(JSContext *cx);
  308.  
  309. /*
  310.  * Friend-exported API entry point to call a mapping function on each reserved
  311.  * identifier in the scanner's keyword table.
  312.  */
  313. extern JS_FRIEND_API(void)
  314. js_MapKeywords(void (*mapfun)(const char *));
  315.  
  316. /*
  317.  * Report a compile-time error by its number, using ts or cg to show context.
  318.  * Return true for a warning, false for an error.
  319.  */
  320. extern JSBool
  321. js_ReportCompileErrorNumber(JSContext *cx, void *handle, uintN flags,
  322.                             uintN errorNumber, ...);
  323.  
  324. extern JSBool
  325. js_ReportCompileErrorNumberUC(JSContext *cx, void *handle, uintN flags,
  326.                               uintN errorNumber, ...);
  327.  
  328. /* Steal some JSREPORT_* bits (see jsapi.h) to tell handle's type. */
  329. #define JSREPORT_HANDLE 0x300
  330. #define JSREPORT_TS     0x000
  331. #define JSREPORT_CG     0x100
  332. #define JSREPORT_PN     0x200
  333.  
  334. /*
  335.  * Look ahead one token and return its type.
  336.  */
  337. extern JSTokenType
  338. js_PeekToken(JSContext *cx, JSTokenStream *ts);
  339.  
  340. extern JSTokenType
  341. js_PeekTokenSameLine(JSContext *cx, JSTokenStream *ts);
  342.  
  343. /*
  344.  * Get the next token from ts.
  345.  */
  346. extern JSTokenType
  347. js_GetToken(JSContext *cx, JSTokenStream *ts);
  348.  
  349. /*
  350.  * Push back the last scanned token onto ts.
  351.  */
  352. extern void
  353. js_UngetToken(JSTokenStream *ts);
  354.  
  355. /*
  356.  * Get the next token from ts if its type is tt.
  357.  */
  358. extern JSBool
  359. js_MatchToken(JSContext *cx, JSTokenStream *ts, JSTokenType tt);
  360.  
  361. JS_END_EXTERN_C
  362.  
  363. #endif /* jsscan_h___ */
  364.